package org.app.data.temp;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import org.app.Ports;

public class MyBean {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	
	/**
	 * 获取类中某个变量的 类型
	 * 若为 泛型 类型
	 * 只能通过获取 类中属性Field的泛型 ，且类中已先显式声明
	 * 若有继承 父类的变量 ，则需递归调用；
	 * @param name
	 * @param type
	 * @return
	 */
	public Class getType(String name, Class type) {// 泛型 ，嵌套 泛型等
		if (type == Object.class)
			return type;
		Class clazz = null;
		try {
			Field f = type.getDeclaredField(name);
			Type typ = f.getGenericType();

			if (typ instanceof ParameterizedType) {// 泛型
			//	System.out.println("泛型");
				ParameterizedType pt = (ParameterizedType) typ;
				Type[] ts = pt.getActualTypeArguments();

				clazz = (Class) ts[ts.length - 1]; // 对于 Map型 只 考虑 Type[1]
													// ；不处理嵌套泛型
			}

			else {
				clazz = (Class) typ;
			//	System.out.print(clazz.isArray());

				if (clazz.isArray()) {//数组
					System.out.println("Array:");
					clazz = clazz.getComponentType();// /
				}
			}

		//	System.out.println("type:" + clazz);
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
			return getType(name, type.getSuperclass()); //递归
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return clazz;
	}
	
	public static <T>void visit(T t,Ports port){
		BeanInfo bean = null;
		try {
			bean = Introspector.getBeanInfo(t.getClass());
		} catch (IntrospectionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return ;
		}
		PropertyDescriptor[] pds=bean.getPropertyDescriptors();
	
	//	System.out.println(pds.length);
		for(PropertyDescriptor pd:pds){
			Class type=pd.getPropertyType();
			String name=pd.getName();
			if(name.equals("class"))continue;
			port.execute(pd);
		}

	}
	
	/**
	 * obj为数组
	 * 包括 int[] ,double[] ,float[] ,String[] 等
	 * @param obj
	 * @return
	 */
	public List toList(Object obj){
		List list=new ArrayList();
		Class type=obj.getClass();
		if(type.isArray()){
		//	type=type.getComponentType();
			int size=Array.getLength(obj);
			for(int i=0;i<size;i++){
				list.add(Array.get(obj, i));
			}
		}
		
		
		return list;
	}
	
	/**
	 * List-->Array
	 * @param list
	 * @param type
	 * @return
	 */
	protected <T> T[] toArray(List list, Class<T> type) {// 

		T[] t = (T[]) Array.newInstance(type, list.size());
		list.toArray(t);
		return t;
	}
	
	public void showBean(Class type){
		BeanInfo bean;
		try {
			bean = Introspector.getBeanInfo(type.getClass());
			PropertyDescriptor[] pds = bean.getPropertyDescriptors();
			for(PropertyDescriptor pd:pds){//对应 getXXX()
				if(pd.getName().equals("class"))
					continue;
			}

			Field []fs=type.getDeclaredFields();
			for(Field f:fs){//若有父类 ，则无法获取继承的属性，可用递归
				
			}
			
			//对于反射设置 bean,若类型不一致，
			//则field.set(obj,value)有异常，
			//可在bean中新增对于的set()后使 再PropertyDescriptor 设置
			//Field f=type.getDeclaredField(name);
			//PropertyDescriptor pd = new PropertyDescriptor(name,type);
			//pd.getWriteMethod().invoke(t, value);
		} catch (IntrospectionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
	}

}
